home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 / Ham Radio 2000.iso / ham2000 / packet / tf27bsrc / tfd.c < prev    next >
Text File  |  1995-06-07  |  29KB  |  873 lines
  1. /**************************************************************************\
  2. *                                                                          *
  3. *                                                                          *
  4. *    *****                      *****                                      *
  5. *      *****                  *****                                        *
  6. *        *****              *****                                          *
  7. *          *****          *****                                            *
  8. *            *****      *****                                              *
  9. *              *****  *****                                                *
  10. *            *****      *****                                              *
  11. *          *****          *****          The Firmware.                     *
  12. *        *****              *****        Portable. Compatible.             *
  13. *      *****                  *****      Public Domain.                    *
  14. *    *****                      *****    By NORD><LINK.                    *
  15. *                                                                          *
  16. *                                                                          *
  17. *                                                                          *
  18. *    TFD.C   -   The Firmware, Teil 4                                      *
  19. *                                                                          *
  20. *                Dieser Teil ist eine Zusammenfassung der                  *
  21. *                zeitunkritischsten Funktionen und kann somit mit der      *
  22. *                groessten Platzersparnis optimiert werden.                *
  23. *                                                                          *
  24. *                                                                          *
  25. *    angelegt:      DC4OX                                                  *
  26. *    modifiziert:   DL8ZAW, 04.05.91                                       *
  27. *                   sl2par(): Initialisieren von ...                       *
  28. *                             Fpar:  IRTT in 10 ms - Schritten             *
  29. *                             A1par: A1 fuer SRTT-Berechnung               *
  30. *                                    (steigendes RTT)                      *
  31. *                             A2par: A2 fuer SRTT-Berechnung               *
  32. *                                    (fallendes RTT)                       *
  33. *                             Bpar:  B fuer Setzen von T1 (T1 = B x SRTT)  *
  34. *                             Ipar:  max. Framelaenge fuer I-Poll          *
  35. *                             DApar: DAMA-Timer in Sekunden                *
  36. *                                    (nach Ablauf wird DAMA-Modus          *
  37. *                                     abgeschaltet)                        *
  38. *                             ... mit Werten aus Eprom                     *
  39. *                   Bcmd():   Setzen/anzeigen des DAMA-Timers (s. DApar)   *
  40. *                                                                          *
  41. *                   DL8ZAW, 18.05.91                                       *
  42. *                   sl2par(): Bpar durch A3par erstezt. (B = A3)           *
  43. *                             M7par - Maskieren mit 7 bit (Terminalmodus)  *
  44. *                                                                          *
  45. *                   DL8ZAW, 05.06.91                                       *
  46. *                   Bcmd(): ohne Parameter Anzeige in der Form:            *
  47. *                           "aktueller Wert / Anfangswert" vom DAMA-Timer  *
  48. *                                                                          *
  49. *                   DL8ZAW, 10.06.91                                       *
  50. *                   Bcmd(): beim Setzen von DApar gleichzeitig damati      *
  51. *                           auf Wert von DApar setzen.                     *
  52. *                                                                          *
  53. *                   DL8ZAW, 25.07.91                                       *
  54. *                   sl2par(): Initialisieren von Walt und Palt:            *
  55. *                             Werte fuer Slottime und P-Persistance vor    *
  56. *                             dem automatischen Umschalten in den DAMA-    *
  57. *                             Modus                                        *
  58. *                                                                          *
  59. *                   DB2OS,  30.08.91                                       *
  60. *                   Bcmd(): ohne Parameter jetzt Anzeige in der Form:      *
  61. *                           "Anfangswert (aktueller Wert)", wie Ycmd()     *
  62. *                                                                          *
  63. *                   DB2OS,  17.09.91                                       *
  64. *                   UIpar und defUIp für UI+.                              *
  65. *                                                                          *
  66. *                   DL8ZAW, 27.03.92                                       *
  67. *                   l3init(): entfernt (wird nicht benoetigt fuer TF)      *
  68. *                                                                          *
  69. *                   DB2OS,  23.06.92                                       *
  70. *                   sl2par(): Walt entfernt, wegen Problemen mit DCD       *
  71. *                                                                          *
  72. *                   DB2OS,  18.10.92                                       *
  73. *                   hpinch(): Echo - ^Zeichenwandlung nur bei 7Bit.        *
  74. *                                                                          *
  75. *                   DB2OS,  20.10.92                                       *
  76. *                   delich(): BS/DEL - Spezialbehandlung bei '^'Ausgabe.   *
  77. *                                                                          *
  78. *                   DG0FT, DB2OS, 21.6.93                                  *
  79. *                   Ucmd() geändert, damit nur noch bei Upar == 2 die      *
  80. *                   //Q-Funktion eingeschaltet ist.                        *
  81. *                                                                          *
  82. *                   DB2OS, 27.6.93                                         *
  83. *                   Vcmd(): Hatte keine Funktion mehr..                    *
  84. *                           Jetzt Ausgabe der Firmware Version (ALL.H)     *
  85. *                                                                          *
  86. *                   DB2OS,  23.11.93                                       *
  87. *                   M7par: 7Bit Ausgabe im Terminal Mode entfernt.         *
  88. *                                                                          *
  89. *                   DG2FEF, 18.07.94                                       *
  90. *                   Bcmd(): Stillgelegt, gibt keinen Timeout mehr.         *
  91. *                                                                          *
  92. *                   DB2OS,  12.08.94                                       *
  93. *                   A1par und A2par fⁿr den SRTT entfernt.                 *
  94. *                   MHEARD entfernt.                                       *
  95. *                                                                          *
  96. *                   DB2OS,  27.08.94                                       *
  97. *                   Bcmd(): Jetzt Anzeige für Anzahl der Hauptschleifen-   *
  98. *                   durchgänge in Rounds per Second.                       *
  99. *                   lxinit(): Variablen loops und rps initialisieren.      *                                                       *
  100. *                   sl2par(): alias und defID (Alias-Call) entfernt.       *
  101. *                                                                          *
  102. *                   DB2OS,  02.09.94                                       *
  103. *                   hpinch(): CTRL-Zeichen im Terminal-Mode werden als     *
  104. *                             "." ausgeben. Lediglich BELL und TAB werden  *
  105. *                             transparent im Echo ans Terminal geschickt.  *
  106. \**************************************************************************/
  107.  
  108.  
  109.  
  110.  
  111.  
  112. /*                                                             Includes   */
  113. /**************************************************************************/
  114.  
  115. #include "all.h"         /* allgemeine Festlegungen                       */
  116. #include "version.h"     /* FEF enthält nur Versionsstring                */
  117. #include "tf.h"          /* Festlegungen/Datenstrukturen fuer TheFirmware */
  118. #include "l2.h"          /* Festlegungen/Datenstrukturen fuer den Level 2 */
  119. #include "tfext.h"       /* globale Variable / nicht int-Funktionen       */
  120.  
  121.  
  122.  
  123. static unsigned par;
  124.  
  125.  
  126. /**************************************************************************\
  127. *                                                                          *
  128. * "set level 2 parameter"                                                  *
  129. *                                                                          *
  130. \**************************************************************************/
  131.  
  132. VOID sl2par()
  133.   {
  134.     unsigned n;
  135.  
  136.     if (!iswarm())
  137.       {
  138.         cpyid(myid,defIp);
  139.         Ypar  = defYp;
  140.         Tpar  = defTp;
  141.         Wpar  = defWp;
  142.         Ppar  = defPp;
  143.         Opar  = defOp;
  144.         Npar  = defNp;
  145.         T2par = defT2p;
  146.         T3par = defT3p;
  147.         Rpar  = defRp;
  148.         Fpar  = defFp;
  149.         A3par = defA3p;
  150.         Ipar  = defIPp;
  151.         UIpar = defUIp;
  152.       }
  153.   }
  154.  
  155.  
  156.  
  157.  
  158.  
  159. /**************************************************************************\
  160. *                                                                          *
  161. * "level x initialize"             FEF                                     *
  162. *                                                                          *
  163. \**************************************************************************/
  164.  
  165. VOID lxinit()
  166.   {
  167.     unsigned n;
  168.  
  169.     inithd(&statml);
  170.     inithd(&smonfl);
  171.     for (n = 0; n < LINKNMBR; ++n)
  172.       {
  173.         inithd(&chnlml[n]);
  174.         chnlbc[n] = 0;             /* FEF */
  175.       }
  176.     loops       =
  177.     rps         =
  178.     sec100      =
  179.     incnt       =
  180.     isctlr      = (unsigned) (
  181.     mifmbp      = (MBHEAD *) (
  182.     ishmod      =
  183.     hmstat      =
  184.     actch       =
  185.     ticks       =
  186.     oldtic      = NULL ));
  187.     if (!iswarm())
  188.       {
  189.         Apar        = defAp;
  190.         Epar        = defEp;
  191.         Mpar        = defMp;
  192.         Xpar        = defXp;
  193.         Zpar        = defZp;
  194.         VCpar       = defVCp;
  195.         Dpar        = defDp;
  196.         xFpar       = defxFp;
  197.         eudate      =
  198.         time.second =
  199.         time.minute =
  200.         time.hour   =
  201.         time.day    =
  202.         time.month  =
  203.         time.year   =
  204.         mftsel      =
  205.         Upar        =
  206.         Utcnt       =
  207.         ch0via[0]   =
  208.         mftidl[0]   = NULL;
  209.         cpyid(ch0id,cqid);
  210.         magicn      = MAGIC;
  211.         stamp       = defxSp;
  212.       }
  213.   }
  214.  
  215.  
  216.  
  217.  
  218. /**************************************************************************\
  219. *                                                                          *
  220. * "host put input character"                                               *
  221. *                                                                          *
  222. \**************************************************************************/
  223. VOID hpinch(ch)
  224. unsigned ch;
  225. {
  226.   if (Epar == YES)                   /* Echo eingeschaltet?               */
  227.     if (!incnt && ch == defESC)      /* Kein Hostmode?                    */
  228.       hputs("* ");                   /* Prompt für ESC-Zeichen ausgeben.  */
  229.     else
  230.       if (    ch >= ' '
  231.            || ch == BELL
  232.            || ch == TAB  )           /* darstellbare Zeichen ausgeben     */
  233.         hputc(ch);
  234.       else
  235.         hputc('.');                  /* Ersatz für Control-Zeichen        */
  236. }
  237.  
  238.  
  239.  
  240. /**************************************************************************\
  241. *                                                                          *
  242. * "delete input character"                                                 *
  243. *                                                                          *
  244. \**************************************************************************/
  245.  
  246. VOID delich()
  247.   {
  248.     unsigned ch;
  249.  
  250.     --incnt;
  251.     ch = *--inbufp & 0xFF;
  252.     if (!incnt && ch == defESC)
  253.       {
  254.         hpbsb();
  255.         hpbsb();
  256.       }
  257.     else
  258.       if (Epar == YES)                /* Echo eingeschaltet           */
  259.         if (ch != BELL)                     /* und kein Bell..              */
  260.           hpbsb();                         /* Zeichen löschen               */
  261.         else
  262.           hputc(ch);
  263.   }
  264.  
  265.  
  266.  
  267.  
  268.  
  269. /**************************************************************************\
  270. *                                                                          *
  271. * "host put backspace space backspace"                                     *
  272. *                                                                          *
  273. \**************************************************************************/
  274.  
  275. VOID hpbsb()
  276.   {
  277.     hputs("\010 \010");
  278.   }
  279.  
  280.  
  281.  
  282.  
  283.  
  284. /**************************************************************************\
  285. *                                                                          *
  286. *                                                                          *
  287. *                                                                          *
  288. \**************************************************************************/
  289.  
  290. VOID Acmd()
  291.   {
  292.     if (!incnt)
  293.       rsppar(Apar);
  294.     else
  295.       if ((par = bgetp()) <= 1)
  296.         {
  297.           Apar = par;
  298.           rspsuc();
  299.         }
  300.       else
  301.         rspiv(par);
  302.   }
  303.  
  304.  
  305.  
  306.  
  307. /**************************************************************************\
  308. *                                                                          *
  309. * Bcmd:  RPS-Anzeige (Rounds per Seconds) früher DAMA-Timer.               *
  310. *        Hauptschleifendurchgänge pro Sekunde.                             *
  311. *                                                                          *
  312. \**************************************************************************/
  313. VOID Bcmd()
  314.   {
  315.     rspini(HMRSMSG);
  316.     hputud(rps);
  317.     rspex();
  318.   }
  319.  
  320.  
  321.  
  322. /**************************************************************************\
  323. *                                                                          *
  324. *                                                                          *
  325. *                                                                          *
  326. \**************************************************************************/
  327.  
  328. VOID Ecmd()
  329.   {
  330.     if (!incnt)
  331.       rsppar(Epar);
  332.     else
  333.       if ((par = bgetp()) <= 1)
  334.         {
  335.           Epar = par;
  336.           rspsuc();
  337.         }
  338.       else
  339.         rspiv(par);
  340.   }
  341.  
  342.  
  343.  
  344.  
  345.  
  346. /**************************************************************************\
  347. *                                                                          *
  348. *                                                                          *
  349. *                                                                          *
  350. \**************************************************************************/
  351.  
  352. VOID Hcmd()
  353.   {
  354.     rspic('H');
  355.   }
  356.  
  357.  
  358.  
  359.  
  360.  
  361. /**************************************************************************\
  362. *                                                                          *
  363. *                                                                          *
  364. *                                                                          *
  365. \**************************************************************************/
  366.  
  367. VOID Jcmd()
  368.   {
  369.     if (incnt >= 4)
  370.       if (upcase(*inbufp++) == 'H')
  371.         if (upcase(*inbufp++) == 'O')
  372.           if (upcase(*inbufp++) == 'S')
  373.             if (upcase(*inbufp++) == 'T')
  374.               {
  375.                 incnt -= 4;
  376.                 if (!nxtnos())
  377.                   rsppar(ishmod);
  378.                 else
  379.                   if ((par = bgetp()) <= 1)
  380.                     {
  381.                       rspsuc();
  382.                       ishmod = par;
  383.                     }
  384.                   else
  385.                     rspiv(par);
  386.                 return;
  387.               }
  388.     rspic('J');
  389.   }
  390.  
  391.  
  392.  
  393.  
  394.  
  395. /**************************************************************************\
  396. *                                                                          *
  397. *                                                                          *
  398. *                                                                          *
  399. \**************************************************************************/
  400.  
  401.  
  402.  
  403. VOID bgetti(p1,p2,p3)                                /* "buffer get time" */
  404.  
  405. char *p1;
  406. char *p2;
  407. char *p3;
  408.  
  409.   {
  410.     *p1 = bgetp();
  411.     --incnt;
  412.     ++inbufp;
  413.     *p2 = bgetp();
  414.     --incnt;
  415.     ++inbufp;
  416.     *p3 = bgetp();
  417.   }
  418.  
  419.  
  420.  
  421. VOID Kcmd()
  422.   {
  423.     if (!incnt)
  424.       {
  425.         rspini(HMRSMSG);
  426.         hputud(stamp);
  427.         hputc(' ');
  428.         hputbt(&time);
  429.         rspex();
  430.       }
  431.     else
  432.       {
  433.         par = bgetp();
  434.         if (!incnt)
  435.           {
  436.             if (par <= 2)
  437.               {
  438.                 stamp = par;
  439.                 rspsuc();
  440.               }
  441.             else
  442.               rspiv(par);
  443.           }
  444.         else
  445.           {
  446.             par = *inbufp & 0xFF;
  447.             incnt += 2;
  448.             inbufp -= 2;
  449.             switch (par)
  450.               {
  451.                 case '.' :  eudate = YES;
  452.                             bgetti(&time.day,&time.month,&time.year);
  453.                             break;
  454.                 case '/' :  eudate = NO;
  455.                             bgetti(&time.month,&time.day,&time.year);
  456.                             break;
  457.                 case ':' :  bgetti(&time.hour,&time.minute,&time.second);
  458.                             break;
  459.               }
  460.             rspsuc();
  461.           }
  462.       }
  463.   }
  464.  
  465.  
  466.  
  467.  
  468.  
  469. /**************************************************************************\
  470. *                                                                          *
  471. *                                                                          *
  472. *                                                                          *
  473. \**************************************************************************/
  474.  
  475. VOID Qcmd()
  476.   {
  477.     if (incnt >= 3)
  478.       if (upcase(*inbufp++) == 'R')
  479.         if (upcase(*inbufp++) == 'E')
  480.           if (upcase(*inbufp++) == 'S')
  481.             {
  482.               magicn = 0;
  483.               reset();
  484.             }
  485.     rspic('Q');
  486.   }
  487.  
  488.  
  489.  
  490.  
  491.  
  492. /**************************************************************************\
  493. *                                                                          *
  494. *                                                                          *
  495. *                                                                          *
  496. \**************************************************************************/
  497.  
  498. VOID Ucmd()
  499.   {
  500.     char       *txt;
  501.     unsigned    n;
  502.     unsigned    ch;
  503.  
  504.     if (!incnt)
  505.       {
  506.         rspini(HMRSMSG);
  507.         hputud(Upar);
  508.         if (Utcnt != 0)
  509.           {
  510.             hputc(' ');
  511.             for (txt = Utxt, n = 0; n < Utcnt; ++n)
  512.               hputcc(*txt++);
  513.           }
  514.         rspex();
  515.       }
  516.     else
  517.       if ((ch = *inbufp & 0xFF) >= '0' && ch <= '9')
  518.         if ((par = bgetp()) <= 2)
  519.           {
  520.             nxtnos();
  521.             if (incnt <= UTXTLEN)
  522.               {
  523.                 Upar = par;
  524.                 if (incnt != 0)
  525.                   for (Utcnt = 0, txt = Utxt; incnt != 0; )
  526.                     {
  527.                       *txt++ = *inbufp++;
  528.                       ++Utcnt;
  529.                       --incnt;
  530.                     }
  531.                 if (Upar && !Utcnt)
  532.                   {
  533.                     rspini(HMRFMSG);
  534.                     hputs("NO MESSAGE AVAILABLE");
  535.                     rspexb();
  536.                     Upar = NO;
  537.                   }
  538.                 else
  539.                   rspsuc();
  540.               }
  541.             else
  542.               {
  543.                 rspini(HMRFMSG);
  544.                 hputs("MESSAGE TOO LONG");
  545.                 rspexb();
  546.               }
  547.           }
  548.         else
  549.           rspiv(par);
  550.       else
  551.         rspipa();
  552.   }
  553.  
  554.  
  555.  
  556.  
  557.  
  558. /**************************************************************************\
  559. *                                                                          *
  560. *  VERSION                                                                 *
  561. *                                                                          *
  562. \**************************************************************************/
  563.  
  564. VOID Vcmd()
  565.   {
  566.     rspini(HMRSMSG);
  567.     hputs(VERSION);           /* Ausgabe der Versions-Nummer, siehe ALL.H */
  568.     rspex();
  569.   }
  570.  
  571.  
  572.  
  573. /**************************************************************************\
  574. *                                                                          *
  575. *                                                                          *
  576. *                                                                          *
  577. \**************************************************************************/
  578.  
  579. VOID Xcmd()
  580.   {
  581.     if (!incnt)
  582.       rsppar(Xpar);
  583.     else
  584.       if ((par = bgetp()) <= 1)
  585.         {
  586.           Xpar = par;
  587.           rspsuc();
  588.         }
  589.       else
  590.         rspiv(par);
  591.   }
  592.  
  593.  
  594.  
  595.  
  596.  
  597. /**************************************************************************\
  598. *                                                                          *
  599. *                                                                          *
  600. *                                                                          *
  601. \**************************************************************************/
  602.  
  603. VOID Zcmd()
  604.   {
  605.     if (!incnt)
  606.       rsppar(Zpar);
  607.     else
  608.       if ((par = bgetp()) <= (FZFLOW | FZXONOFF))
  609.         {
  610.           Zpar = par;
  611.           rspsuc();
  612.         }
  613.       else
  614.         rspiv(par);
  615.   }
  616.  
  617.  
  618.  
  619.  
  620.  
  621. /**************************************************************************\
  622. *                                                                          *
  623. * "list channel"                                                           *
  624. *                                                                          *
  625. \**************************************************************************/
  626.  
  627. VOID listch(chnl)
  628.  
  629. unsigned chnl;
  630.  
  631.   {
  632.     unsigned    lstate;
  633.     unsigned    mbnmbr;
  634.     unsigned    unacked;
  635.     LNKBLK     *linkp;
  636.  
  637.     if (chnl != 0)
  638.       {
  639.         linkp = &lnktbl[chnl - 1];
  640.         lstate = linkp->state;
  641.       }
  642.     hputc(chnl == actch ? '+' : ' ');
  643.     hputc('(');
  644.     hputud(chnl);
  645.     hputs(") ");
  646.     if (!chnl)
  647.       {
  648.         hputid(ch0id);
  649.         hputv(NO,ch0via);
  650.       }
  651.     else
  652.       if (lstate != L2SDSCED)
  653.         {
  654.           hputid(linkp->dstid);
  655.           hputv(NO,linkp->viaidl);
  656.         }
  657.     if (    (mbnmbr = mbcnt(!chnl ? &smonfl : &chnlml[chnl - 1],MBALL)) != 0
  658.          || (chnl != 0 && lstate != L2SDSCED)
  659.        )
  660.       {
  661.         hcrlf();
  662.         hputs("      receive ");
  663.         hputud(mbnmbr);
  664.       }
  665.     if (chnl != 0 && lstate != L2SDSCED)
  666.       {
  667.         unacked = (linkp->VS - linkp->lrxdNR) & 0x7;
  668.         hputs("   send ");
  669.         hputud(linkp->tosend - unacked);
  670.         hputs("   unacked ");
  671.         hputud(unacked);
  672.         if (    unacked != 0
  673.              || lstate < L2SIXFER
  674.              || linkp->T1 != 0
  675.            )
  676.           {
  677.             hputs("   retries ");
  678.             hputud(linkp->tries);
  679.           }
  680.       }
  681.     hcrlf();
  682.   }
  683.  
  684.  
  685.  
  686.  
  687.  
  688. /**************************************************************************\
  689. *                                                                          *
  690. * "buffer get via list"                                                    *
  691. *                                                                          *
  692. \**************************************************************************/
  693.  
  694. bgetvl(check,vial)
  695.  
  696. unsigned    check;
  697. char       *vial;
  698.  
  699.   {
  700.     static char        viabuf[L2VLEN + 1];
  701.     static char       *viabp;
  702.     static unsigned    n;
  703.     static unsigned    getres;
  704.  
  705.     skpvia();
  706.     for (n = 0, viabp = viabuf; n < L2VNUM; ++n, viabp += L2IDLEN)
  707.       if ((getres = bgetid(check,viabp)) == ERROR)
  708.         return (ERROR);
  709.       else
  710.         if (!getres) break;
  711.     *viabp = '\0';
  712.     while (incnt != 0)
  713.       if (*inbufp != ' ')
  714.         return (ERROR);
  715.       else
  716.         {
  717.           ++inbufp;
  718.           --incnt;
  719.         }
  720.     cpyidl(vial,viabuf);
  721.     return (*vial != '\0');
  722.   }
  723.  
  724.  
  725.  
  726.  
  727.  
  728. /**************************************************************************\
  729. *                                                                          *
  730. * "skip via"                                                               *
  731. *                                                                          *
  732. \**************************************************************************/
  733.  
  734. VOID skpvia()
  735.   {
  736.     static char        id[L2IDLEN];
  737.     static char       *bpsav;
  738.     static char       *idp;
  739.     static unsigned    cntsav;
  740.     static unsigned    n;
  741.     static unsigned    chr;
  742.  
  743.     bpsav = inbufp;
  744.     cntsav = incnt;
  745.     if (bgetid(NO,id) == TRUE)
  746.       {
  747.         idp = id;
  748.         if (*idp++ == 'V')
  749.           {
  750.             for (n = 0; n < L2CALEN - 1; ++n)
  751.               if ((chr = *idp++ & 0xFF) != ' ')
  752.                 if (!((!n && chr == 'I') || (n == 1 && chr == 'A'))) break;
  753.             if (n == L2CALEN - 1) return;
  754.           }
  755.       }
  756.     inbufp = bpsav;
  757.     incnt = cntsav;
  758.   }
  759.  
  760.  
  761.  
  762.  
  763.  
  764. /**************************************************************************\
  765. *                                                                          *
  766. * "buffer get ID"                                                          *
  767. *                                                                          *
  768. \**************************************************************************/
  769.  
  770. bgetid(check,gidp)
  771.  
  772. unsigned    check;
  773. char       *gidp;
  774.  
  775.   {
  776.     static char        id[L2IDLEN];
  777.     static char       *idp;
  778.     static unsigned    innmbr;
  779.     static unsigned    n;
  780.     static unsigned    inchr;
  781.  
  782.     for (idp = id, n = 0; n < L2CALEN; ++n) *idp++ = ' ';
  783.     *idp = 0x60;
  784.     nxtnos();
  785.     idp = id;
  786.     n = 0;
  787.  
  788.     while (incnt != 0)
  789.       {
  790.         if ((inchr = upcase(*inbufp & 0xFF)) == ' ' || inchr == ',') break;
  791.         if (inchr < ' ') return (ERROR);
  792.         if (inchr == '-')
  793.           {
  794.             if (n == 0 || incnt == 0) return (ERROR);
  795.             ++inbufp;
  796.             --incnt;
  797.             if ((inchr = *inbufp & 0xFF) < '0' || inchr > '9') return (ERROR);
  798.             ++inbufp;
  799.             --incnt;
  800.             innmbr = inchr - '0';
  801.             if (incnt != 0)
  802.               if ((inchr = *inbufp & 0xFF) >= '0' && inchr <= '9')
  803.                 {
  804.                   innmbr *= 10;
  805.                   innmbr += (inchr - '0');
  806.                   if (innmbr > 15) return (ERROR);
  807.                   ++inbufp;
  808.                   --incnt;
  809.                 }
  810.             id[L2IDLEN - 1] = (innmbr << 1) | 0x60;
  811.             break;
  812.           }
  813.         else
  814.           {
  815.             if (n++ == L2CALEN) return (ERROR);
  816.             *idp++ = inchr;
  817.             ++inbufp;
  818.             --incnt;
  819.           }
  820.       } /* end while */
  821.  
  822.     while (incnt != 0)
  823.       {
  824.         if (!((inchr = *inbufp & 0xFF) == ' ' || inchr == ',')) break;
  825.         ++inbufp;
  826.         --incnt;
  827.         if (inchr == ',') break;
  828.       }
  829.  
  830.     if (!n) return (FALSE);
  831.     if (fvalca(check,id) == ERROR) return (ERROR);
  832.     cpyid(gidp,id);
  833.     return (TRUE);
  834.   }
  835.  
  836.  
  837.  
  838.  
  839.  
  840. /**************************************************************************\
  841. *                                                                          *
  842. * "hpost put fixed unsigned"                                               *
  843. *                                                                          *
  844. \**************************************************************************/
  845.  
  846. VOID hputfu(u)
  847.  
  848. unsigned u;
  849.  
  850.   {
  851.     static BOOLEAN    out;
  852.     static unsigned   div;
  853.     static unsigned   digit;
  854.     static unsigned   n;
  855.  
  856.     for (out = FALSE, div = 10000, n = 0; n < 5; ++n)
  857.       {
  858.         if ((digit = u/div) != 0 || out == TRUE || div == 1)
  859.           {
  860.             hputc(digit + '0');
  861.             out = TRUE;
  862.           }
  863.         else
  864.           hputc(' ');
  865.         u  %= div;
  866.         div /= 10;
  867.       }
  868.   }
  869.  
  870.  
  871. /* Ende von TFD.C */
  872.  
  873.